package kr.hkit.android_bookmgr.util;

import java.io.File;
import java.io.IOException;

import kr.hkit.android_bookmgr.R;

import com.nostra13.universalimageloader.cache.disc.naming.Md5FileNameGenerator;
import com.nostra13.universalimageloader.core.DisplayImageOptions;
import com.nostra13.universalimageloader.core.ImageLoader;
import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff.Mode;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.media.ExifInterface;
import android.util.Log;
import android.view.Display;
import android.view.WindowManager;

public class ImageUtil {
	
	//카메라 촬영, 갤러리 내용 이용하여 회전해서 이미지뷰에 뿌리기 소스
	 public static Bitmap getRoundedCornerBitmap(Bitmap bitmap) {  
	        Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888);  
	        Canvas canvas = new Canvas(output);  
	        final int color = 0xff424242;  
	        final Paint paint = new Paint();  
	        final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());  
	        final RectF rectF = new RectF(rect);  
	        final float roundPx = 10;  
	  
	        paint.setAntiAlias(true);  
	        canvas.drawARGB(0, 0, 0, 0);  
	        paint.setColor(color);  
	        canvas.drawRoundRect(rectF, roundPx, roundPx, paint);  
	  
	        paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));  
	        canvas.drawBitmap(bitmap, rect, rect, paint);  
	  
	        bitmap.recycle();  
	        bitmap = output;  
	  
	        return bitmap;  
	    }  
	  
	
	 
	 /** 
      * 지정한 패스의 파일을 화면 크기에 맞게 읽어서 Bitmap을 리턴 
      * 
      * @param context 
      *       application context 
      * @param imgFilePath 
      *       bitmap file path 
      * @return Bitmap 
      * @throws IOException 
      */  
    @SuppressLint("ServiceCast")
	public static Bitmap loadBackgroundBitmap(Context context, String imgFilePath) {  
        File file = new File(imgFilePath);  
        if (file.exists() == false) {  
            return null;  
        }  
  
        // 폰의 화면 사이즈를 구한다.  
        Display display = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();  
        int displayWidth = display.getWidth();  
        int displayHeight = display.getHeight();  
  
        // 읽어들일 이미지의 사이즈를 구한다.  
        BitmapFactory.Options options = new BitmapFactory.Options();  
        options.inPreferredConfig = Config.RGB_565;  
        options.inJustDecodeBounds = true;  
        BitmapFactory.decodeFile(imgFilePath, options);  
  
        // 화면 사이즈에 가장 근접하는 이미지의 스케일 팩터를 구한다.  
        // 스케일 팩터는 이미지 손실을 최소화하기 위해 짝수로 한다.  
        float widthScale = options.outWidth / displayWidth;  
        float heightScale = options.outHeight / displayHeight;  
        float scale = widthScale > heightScale ? widthScale : heightScale;  
                  
       /* if (scale >= 8)  
            options.inSampleSize = 8;  
        else if (scale >= 6)  
            options.inSampleSize = 6;  
        else if (scale >= 4)  
            options.inSampleSize = 4;  
        else if (scale >= 2)  
            options.inSampleSize = 2;  
        else  
            options.inSampleSize = 1; */ 
        
        if (scale >= 8) { 
            options.inSampleSize = 8;  
        } else if (scale >= 6) {
            options.inSampleSize = 6;  
        } else if (scale >= 4) {  
            options.inSampleSize = 4;  
        } else {
            options.inSampleSize = 4;  
        }
        
        //options.inSampleSize = 8;  //화질줄였음ㅋㅋ
        
        options.inJustDecodeBounds = false;  
  
        return BitmapFactory.decodeFile(imgFilePath, options);  
    }         
	
	
	/** 
     * 지정한 패스의 파일의 EXIF 정보를 읽어서 회전시킬 각도 구하기 
     * 
     * @param imgFilePath 
     *       bitmap file path 
     * @return degree 
     */  
   public synchronized static int GetExifOrientation(String filepath) {  
       int degree = 0;  
       ExifInterface exif = null;  
         
       try {  
           exif = new ExifInterface(filepath);  
       }   
       catch (IOException e) {  
           Log.e("TAG", "cannot read exif");  
           e.printStackTrace();  
       }  
         
       if (exif != null) {  
           int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, -1);  
             
           if (orientation != -1) {  
               // We only recognize a subset of orientation tag values.  
               switch(orientation) {  
                   case ExifInterface.ORIENTATION_ROTATE_90:  
                       degree = 90;  
                       break;  
                         
                   case ExifInterface.ORIENTATION_ROTATE_180:  
                       degree = 180;  
                       break;  
                         
                   case ExifInterface.ORIENTATION_ROTATE_270:  
                       degree = 270;  
                       break;  
                	   
               }  
           }  
       }  
        
       Log.d("degree", degree+"");
       return degree;  
   }  
 
   /** 
     * 지정한 패스의 파일을 EXIF 정보에 맞춰 회전시키기 
     * 
     * @param bitmap 
     *       bitmap handle 
     * @return Bitmap 
     */  
   public synchronized static Bitmap GetRotatedBitmap(Bitmap bitmap, int degrees) {  
       if (degrees != 0 && bitmap != null) {  
           Matrix m = new Matrix();  
           m.setRotate(degrees, (float) bitmap.getWidth() / 2,  
                   (float) bitmap.getHeight() / 2 );  
           try {  
               Bitmap b2 = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(),  
                       bitmap.getHeight(), m, true);  
               if (bitmap != b2) {  
                   bitmap.recycle();  
                   bitmap = b2;  
               }  
           }   
           catch (OutOfMemoryError ex) {  
               // We have no memory to rotate. Return the original bitmap.  
           }  
       }  
         
       return bitmap;  
   }  
   
   
   //유니버셜 이미지 로더 라이브러리사용
   //DB에 저장되있는 주소 이용해서 출력
   public static void imageLoader(Context context){
		
		ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)
		.threadPriority(Thread.NORM_PRIORITY-2)
		.denyCacheImageMultipleSizesInMemory()
		.discCacheFileNameGenerator(new Md5FileNameGenerator())
		.tasksProcessingOrder(QueueProcessingType.LIFO)
		.writeDebugLogs().build();
		ImageLoader.getInstance().init(config);

	} //ImageLoader
	
	public static DisplayImageOptions dispalyOptions(){
		 DisplayImageOptions options = new DisplayImageOptions.Builder()
			.showImageForEmptyUri(R.drawable.noimage)
			.cacheInMemory(true)
			.cacheOnDisc(true)
			.considerExifParams(true).build();
		return options;
	}//DisplayImageOptions
	

}
